package cn.wolfcode.trip.api.controller;

import cn.wolfcode.trip.base.domain.FriendCircle;
import cn.wolfcode.trip.base.domain.Love;
import cn.wolfcode.trip.base.domain.User;
import cn.wolfcode.trip.base.query.CommentQueryObject;
import cn.wolfcode.trip.base.query.QueryObject;
import cn.wolfcode.trip.base.query.SystemInfoQueryObject;
import cn.wolfcode.trip.base.query.TravelQueryObject;
import cn.wolfcode.trip.base.service.*;
import cn.wolfcode.trip.base.util.JsonResult;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/users")
@Api(value = "用户资源", description = "用户资源控制器")
public class UserController {
    @Autowired
    private IUserService userService;
    @Autowired
    private ITravelService travelService;
    @Autowired
    private IFollowService followService;
    @Autowired
    private ICommentService commentService;
    @Autowired
    private ILoveService loveService;
    @Autowired
    private ISystemInfoService systemInfoService;
    @Autowired
    private IFriendCircleService friendCircleService;

    /**
     * 注册接口
     * 1.资源users/{user}
     * 2.方式 post
     * 3.返回json对象
     *
     * @param user
     * @return
     */
    @PostMapping
    @ApiOperation(value = "注册功能", notes = "其实就是新增用户")
    @ApiResponses({
            @ApiResponse(code = 200, message = "用户注册成功")
    })
    @ApiImplicitParams({
            @ApiImplicitParam(value = "昵称", name = "nickName", dataType = "String", required = true),
            @ApiImplicitParam(value = "邮箱", name = "email", dataType = "String", required = true),
            @ApiImplicitParam(value = "密码", name = "password", dataType = "String", required = true)
    })
    public JsonResult register(User user) {
        JsonResult json = new JsonResult();
        try {
            userService.register(user);
        } catch (Exception e) {
            e.printStackTrace();
            json.mark(e.getMessage());
        }
        return json;
    }

    /**
     * 更新接口
     * 1.资源users/{id}
     * 2.方式 put
     * 3.返回json对象
     *
     * @param user
     * @return
     */
    @PutMapping("{id}")
    public JsonResult updata(User user) {
        JsonResult json = new JsonResult();
        try {
            userService.updata(user);
            json.setData(user);
        } catch (Exception e) {
            e.printStackTrace();
            json.mark(e.getMessage());
        }
        return json;
    }

    /**
     * 获取单个用户的的信息
     */
    @GetMapping("{id}")
    public JsonResult getUser(@PathVariable("id") Long id) {
        JsonResult json = new JsonResult();
        try {
            User user = userService.getUser(id);
            // 共享用户到前端
            json.setData(user);
        } catch (Exception e) {
            e.printStackTrace();
            json.mark("亲,数据正在路上");
        }
        return json;
    }

    /**
     * 获取我的游记资源接口
     * 1.请求资源 /users/{authorId}/travels
     * 2.请求方式 get
     * 3.请求长参数 TravelQueryObject
     * 3.返回值 PageInfo
     */
    @GetMapping("{authorId}/travels")
    public PageInfo query(TravelQueryObject qo) {
        // 按照最后更新时间倒序排序
        qo.setOrderBy("t.lastUpdateTime desc");
        return travelService.query(qo);
    }

    /**
     * 查询当前用户的系统通知的内容 根据通知时间倒序
     * 1.请求资源 users/id/systeminfo
     * 2.请求方式 get
     * 3.请求参数 SystemInfoQueryObject
     * 3.返回值 PageInfo
     */
    @GetMapping("{userId}/systeminfo")
    public PageInfo querySystemInfo(SystemInfoQueryObject qo) {
        qo.setOrderBy("creatTime desc");
        return systemInfoService.query(qo);
    }

    /**
     * 查询当前用户的系统通知的未读通知数
     * 1.请求资源 users/{userId}/systeminfo/state
     * 2.请求方式 get
     * 3.请求长参数 SystemInfoQueryObject
     * 3.返回值 Integer
     */
    @GetMapping("{userId}/systeminfo/state")
    public Integer querySystemInfoState(SystemInfoQueryObject qo) {
        return systemInfoService.selectStateByUserId(qo);
    }

    /**
     * 清除未读通知数量
     * 1.请求资源 {userId}/systeminfo/state
     * 2.请求方式 put
     * 3.请求长参数 userId
     * 3.返回值 无
     */
    @PutMapping("{userId}/systeminfo/state")
    public void updateSystemInfoState(@PathVariable Long userId) {
        systemInfoService.updateStateByUserId(userId);
    }

    /**
     * 查询用户的关注数
     * 1 资源 /users/{id}/follows
     * 2 请求方式 get
     * 3 请求参数 fansId
     * 4 返回结果 count(0)
     */
    @GetMapping("/{fansId}/follows")
    public Integer listByFansId(@PathVariable Long fansId) {
        return followService.listByFansId(fansId);
    }

    /**
     * 查询用户的粉丝数
     * 1 资源 /users/{id}/fans
     * 2 请求方式 get
     * 3 请求参数 userId
     * 4 返回结果 count(0)
     */
    @GetMapping("/{userId}/fans")
    public Integer listByFollowId(@PathVariable Long userId) {
        return followService.listByFollowId(userId);
    }

    /**
     * 查询用户积分数
     * 1 资源 /users/{id}/grade
     * 2 请求方式 get
     * 3 请求参数 userId
     * 4 返回结果 int
     */
    @GetMapping("/{userId}/grade")
    public Integer getGradeById(@PathVariable Long userId) {
        return userService.getGradeById(userId);
    }

    /**
     * 获取用户未读的点赞
     * 1.资源 /users/{authorId}/love
     * 2.请求方式 get
     * 3.请求参数 路径占位符
     * 4.返回结果 未读的点赞数
     */
    @GetMapping("/{authorId}/love/isRead")
    public Integer getForReadCount(@PathVariable Long authorId) {
        return loveService.selectForReadCount(authorId);
    }

    /**
     * 阅读该用户所有的点赞消息
     * 1.资源  /users/{authorId}/love/{isRead}
     * 2.请求方式 put
     * 3.请求参数 路径占位符
     * 4.返回结果 JsonResult
     */
    @PutMapping("/{authorId}/love")
    public JsonResult updateIsRead(@PathVariable Long authorId) {
        loveService.updateIsRead(authorId);
        return new JsonResult();
    }

    /**
     * 查询该用户所有的点赞信息
     * 1.资源  /users/{authorId}/love
     * 2.请求方式 get
     * 3.请求参数 路径占位符
     * 4.返回结果 List<Love>
     */
    @GetMapping("/{authorId}/love")
    public List<Love> selectForLovesByAuthorId(@PathVariable Long authorId) {
        List<Love> list = loveService.selectForLovesByAuthorId(authorId);
        return list;
    }

    /**
     * 获取当前用户的所有(包含关注)朋友圈信息接口
     * 1.资源	/users/{userId}/friendCircle
     * 2.请求方式 get
     * 3.请求参数 路径占位符
     * 4.返回结果 PageInfo<FiendCircle>
     */
    @GetMapping("/{userId}/friendCircle")
    public PageInfo<FriendCircle> selectForFriendCircleList(@PathVariable Long userId, QueryObject qo) {
        //查出该用户的关注人
        List<Long> Ids = userService.selectForFollow(userId);
        //加入自己id
        Ids.add(userId);
        //查出朋友圈信息,按创建时间倒叙
        PageInfo<FriendCircle> list = friendCircleService.selectByUserIds(Ids, qo);
        return list;
    }

    /**
     * 获取当前用户自己的朋友圈信息接口
     * 1.资源	/users/{userId}/mySelfCircle
     * 2.请求方式 get
     * 3.请求参数 路径占位符
     * 4.返回结果 PageInfo<FiendCircle>
     */
    @GetMapping("/{userId}/mySelfCircle")
    public PageInfo<FriendCircle> selectForMySelfCircleList(@PathVariable Long userId, QueryObject qo) {
        //查出自己的所有朋友圈信息,按创建时间倒叙
        PageInfo<FriendCircle> list = friendCircleService.selectByUserId(userId, qo);
        return list;
    }

    /**
     * 获取当前用户的关注用户
     * 1 /资源 /users/{id}/followUser
     * 2 请求方式 get
     * 3 请求参数 当前用户id
     * 4 返回结果 List<user>
     */
    @GetMapping("/{id}/followUser")
    public List<User> list(@PathVariable Long id) {
        //查出该用户的关注人
        List<Long> Ids = userService.selectForFollow(id);
        List<User> follows = userService.selectFollowUsers(Ids);
        return follows;
    }

    /**
     * 获取当前用户的粉丝
     * 1 /资源 /users/{id}/funsUser
     * 2 请求方式 get
     * 3 请求参数 当前用户id
     * 4 返回结果 List<user>
     */
    @GetMapping("/{id}/funsUser")
    public List<User> listForFuns(@PathVariable Long id) {
        //查出该用户的粉丝
        List<Long> Ids = userService.selectForFuns(id);
        List<User> follows = userService.selectFollowUsers(Ids);
        return follows;
    }

    /**
     * 获取我的评论攻略评论和朋友圈评论
     * 1 资源 /users/{userId}/comment
     * 2 请求方式 get
     * 3 请求参数 qo对象(用户id)
     * 4 返回结果 PageInfo
     */
    @GetMapping("/{userId}/comment")
    public PageInfo list(CommentQueryObject qo) {
        PageInfo pageInfo = commentService.listMyComment(qo);
        return pageInfo;
    }

    /**
     * 查询我的评论的未读评论数量
     * 1 资源 /users/{userId}/unread
     * 2 请求方式 get
     * 3 请求参数 用户id
     * 4 返回结果 count
     */
    @GetMapping("/{userId}/unread")
    public Integer getUnreadComment(CommentQueryObject qo) {
        return commentService.getUnreadComment(qo);
    }

    /**
     * 修改我的未读评论为 已读
     * 1 资源 /users/{userId}/changeStates
     * 2 请求方式 put
     * 3 请求参数 用户id
     * 4 返回结果 jsonResult
     */
    @PutMapping("/{userId}/changes")
    public JsonResult changeStates(@PathVariable Long userId) {
        JsonResult result = new JsonResult();
        commentService.changeStates(userId);
        return result;
    }

    /**
     * 获取谁评论了我的消息
     * 1 资源 /users/{id}/unreadMessage
     * 2 请求方式 get
     * 3 请求参数 用户id
     * 4 返回结果 PageInfo
     */
    @GetMapping("{userId}/unreadMessage")
    public PageInfo<Map> listUnreadMessage(CommentQueryObject qo) {
        return commentService.listUnreadMessage(qo);
    }

    /**
     * 当前用户发布朋友圈
     * 1.资源   /users/{user.id}/fiendCircle
     * 2.请求方式 post
     * 3.请求参数 FriendCircle对象
     * 4.返回结果 JsonResult
     */
    @PostMapping("/{user.id}/friendCircle")
    public JsonResult saveFriendCircle(FriendCircle fc) {
        friendCircleService.save(fc);
        return new JsonResult();
    }

    /**
     * 显示当前用户显示可能感兴趣的人
     * 1.资源   /users/{userId}/listInteresteds
     * 2.请求方式 post
     * 3.请求参数 FriendCircle对象
     * 4.返回结果 JsonResult
     */
    @GetMapping("/{userId}/listInteresteds")
    public Object listInteresteds(@PathVariable Long userId) {
        // 查询所有用户，并且过滤自己
        // 可以随机生成一个数，范围就是查询所有用户的数量，然后查询
        return  userService.listInteresteds(userId);
    }

}